home *** CD-ROM | disk | FTP | other *** search
/ Photo CD Demo 1 / Demo.bin / hdf / mac / h10srcst.hqx / Source / HyperHell Source / App NCSA TektoPICT / vgtek.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-04-19  |  26.7 KB  |  1,288 lines
  1. /*
  2.  
  3. vgtek.c by Aaron Contorer 1987 for NCSA
  4. Copyright 1987, Board of Trustees, University of Illinois.
  5.  
  6. Takes Tektronix codes as input; sends output to real graphics devices.
  7.  
  8. CHANGES TO MAKE:
  9. Create a function to make sure a window is attached to a real window.
  10.   Calling program will call this whenever switching between active windows.
  11. Pass virtual window number to RG driver so it can call back.
  12.  
  13.  
  14. */
  15.  
  16. #define FALSE 0
  17. #define TRUE 1
  18. #define MAXVG 20 /* maximum number of VG windows */
  19.  
  20. /* temporary states */
  21. #define HIY 0        /* waiting for various pieces of coordinates */
  22. #define EXTRA 1
  23. #define LOY 2
  24. #define HIX 3
  25. #define LOX 4
  26.  
  27. #define DONE 5        /* not waiting for coordinates */
  28. #define ENTERVEC 6    /* entering vector mode */
  29.  
  30. #define CANCEL 7    /* done but don't draw a line */
  31. #define RS 8        /* RS - incremental plot mode */
  32. #define ESCOUT 9    /* when you receive an escape char after a draw command */
  33. #define CMD0 50        /* got esc, need 1st cmd letter */
  34. #define SOMEL 51    /* got esc L, need 2nd letter */
  35. #define IGNORE 52    /* ignore next char */
  36. #define SOMEM 53    /* got esc M, need 2nd letter */
  37. #define IGNORE2 54
  38. #define INTEGER 60    /* waiting for 1st integer part */
  39. #define INTEGER1 61    /* waiting for 2nd integer part */
  40. #define INTEGER2 62    /* waiting for 3rd (last) integer part */
  41. #define COLORINT 70
  42. #define GTSIZE0 75
  43. #define GTSIZE1 76
  44. #define SOMET 80
  45. #define JUNKARRAY 81
  46. #define STARTDISC 82
  47. #define DISCARDING 83
  48.  
  49. /* output modes */
  50. #define ALPHA 0
  51. #define DRAW 1
  52. #define MARK 3
  53. #define TEMPDRAW 101
  54. #define TEMPMOVE 102
  55. #define TEMPMARK 103
  56.  
  57. /* stroked fonts */
  58. #define CHARWIDE 51        /* total horz. size */
  59. #define CHARTALL 76        /* total vert. size */
  60. #define CHARH 10        /* horz. unit size */
  61. #define CHARV 13        /* vert. unit size */
  62. #define LINE1 2969        /* cursor y for 1st text line */
  63.  
  64. /* RG coordinate space dimensions */
  65. #define RGXSIZE 4096
  66. #define RGYSIZE 4096
  67.  
  68. typedef struct {
  69.     int 
  70.     (*init)(), (*point)(), (*drawline)(), (*newwin)(),
  71.     (*clrscr)(), (*pagedone)(), (*dataline)(), (*pencolor)(),
  72.     (*charmode)(), (*showcur)(), (*lockcur)(), (*hidecur)(),
  73.     (*close)(), (*uncover)(), (*info)(),
  74.     (*gmode)(), (*tmode)(), (*gin)();
  75.     char *(*devname)();
  76.     int (*bell)();
  77. } RGLINK;
  78.  
  79. extern char *malloc();
  80. int donothing();
  81.  
  82. struct VGWINTYPE {
  83.     int RGdevice, RGnum;
  84.     char mode,modesave; /* current output mode */
  85.     char loy,hiy,lox,hix,ex,ey; /* current graphics coordinates */
  86.     char nloy,nhiy,nlox,nhix,nex,ney; /* new coordinates */
  87.     int curx,cury;                /* current composite coordinates */
  88.     int winbot,wintop,winleft,winright,wintall,winwide; 
  89.         /* position of window in virutal space */
  90.     int textcol;    /* text starts in 0 or 2048 */
  91.     int intin;        /* integer parameter being input */
  92.     int pencolor;    /* current pen color */
  93.     int fontnum,charx,chary; /* char size */
  94.     int count; /* for temporary use in special state loops */
  95. };
  96.  
  97. #include <stdio.h>
  98. #include "vgtek.h"
  99. #include "vgfont.h"
  100. #include "tekstor.h"
  101.  
  102. static struct VGWINTYPE VGwin[MAXVG]; /* virtual window descriptors */
  103. static char state[MAXVG],savstate[MAXVG];
  104.     /* save state in a parallel array for speed */
  105. static STOREP VGstore[MAXVG]; /* the store where data for this widow is kept */
  106. static char storing[MAXVG]; /* are we currently saving data from this window */
  107. static int drawing[MAXVG]; /* redrawing or not? */
  108.  
  109. #define NUMSIZES 6 /* number of char sizes */
  110. static int charxset[NUMSIZES] = {56,51,34,31,112,168};
  111. static int charyset[NUMSIZES] = {88,82,53,48,176,264};
  112.  
  113. /*******************************************************************/
  114.  
  115. static donothing()
  116. { }
  117.  
  118.  
  119. static fontnum(vw,n)
  120. int vw,n;
  121. /*
  122.     Set font for window 'vw' to size 'n'.
  123.     Sizes are 0..3 in Tek 4014 standard.
  124.     Sizes 4 & 5 are used internally for Tek 4105 emulation.
  125. */
  126. {
  127.     if (n<0 || n>=NUMSIZES) return(-1);
  128.     VGwin[vw].fontnum=n;
  129.     VGwin[vw].charx=charxset[n];
  130.     VGwin[vw].chary=charyset[n];
  131.     return(0);
  132. }
  133.  
  134.  
  135. static storexy(vw,x,y)
  136. int vw,x,y;
  137. /* set graphics x and y position */
  138. {
  139.     VGwin[vw].curx = x;
  140.     VGwin[vw].cury = y;
  141.  
  142. #ifdef hmmm
  143.     VGwin[vw].ex=x & 3;
  144.     VGwin[vw].lox=(x >> 2) & 31;
  145.     VGwin[vw].hix=(x >> 7) & 31;
  146.     VGwin[vw].ey=y & 3;
  147.     VGwin[vw].loy=(y >> 2) & 31;
  148.     VGwin[vw].hiy=(y >> 7) & 31;
  149. #endif
  150. }
  151.  
  152.  
  153. static joinup(hi,lo,e)
  154. int hi,lo,e;
  155. /* returns the number represented by the 3 pieces */
  156. {
  157.     return (((hi /* & 31 */ ) << 7) | ((lo /* & 31 */ ) << 2) | (e /* & 3 */));
  158. } /* end joinup() */
  159.  
  160.  
  161. static newcoord(vw)
  162. int vw;
  163. /*
  164.     Replace x,y with nx,ny
  165. */
  166. {
  167.     VGwin[vw].hiy = VGwin[vw].nhiy;
  168.     VGwin[vw].hix = VGwin[vw].nhix;
  169.     VGwin[vw].loy = VGwin[vw].nloy;
  170.     VGwin[vw].lox = VGwin[vw].nlox;
  171.     VGwin[vw].ey  = VGwin[vw].ney;
  172.     VGwin[vw].ex  = VGwin[vw].nex;
  173.  
  174.     VGwin[vw].curx = joinup(VGwin[vw].nhix,VGwin[vw].nlox,VGwin[vw].nex);
  175.     VGwin[vw].cury = joinup(VGwin[vw].nhiy,VGwin[vw].nloy,VGwin[vw].ney);
  176. }
  177.  
  178.  
  179. static linefeed(vw)
  180. /* 
  181.     Perform a linefeed & cr (CHARTALL units) in specified window.
  182. */
  183. {
  184. /*    int y=joinup(VGwin[vw].hiy,VGwin[vw].loy,VGwin[vw].ey);*/
  185.     int y=VGwin[vw].cury;
  186.     int x;
  187.  
  188.     if (y>VGwin[vw].chary) y -= VGwin[vw].chary;
  189.     else {
  190.         y=3071 - VGwin[vw].chary;
  191.         VGwin[vw].textcol = 2048 - VGwin[vw].textcol;
  192.     }
  193.     x = VGwin[vw].textcol;
  194.     storexy(vw,x,y);
  195. }
  196.     
  197.  
  198. #ifdef DEBUG
  199. static drawc(vw,c)
  200. int vw;
  201. char c; /* character to draw */
  202. {
  203.     putchar(c);
  204. }
  205. #else
  206. static drawc(vw,c)
  207. int vw;
  208. char c; /* character to draw */
  209. /*
  210.     Draw a stroked character at the current cursor location.
  211.     Uses simple 8-directional moving, 8-directional drawing.
  212. */
  213. {
  214.     int x,y,savex,savey,strokex,strokey;
  215.     int n; /* number of times to perform command */
  216.     char *pstroke; /* pointer into stroke data */
  217.     int hmag,vmag;
  218.  
  219.     if (c==10) {
  220.         linefeed(vw);
  221.         return(0);
  222.     }
  223.  
  224.     if (c==7) {
  225.         (*RG[VGwin[vw].RGdevice].bell) (VGwin[vw].RGnum);
  226.         unstore(VGstore[vw]);
  227.         return(0);
  228.     }
  229.  
  230. #ifdef oldm
  231.     savey=y=joinup(VGwin[vw].hiy,VGwin[vw].loy,VGwin[vw].ey);
  232.     savex=x=joinup(VGwin[vw].hix,VGwin[vw].lox,VGwin[vw].ex);
  233. #endif
  234.     savey=y=VGwin[vw].cury;
  235.     savex=x=VGwin[vw].curx;
  236.  
  237.     if (c==8) {
  238.         if (savex<=VGwin[vw].textcol) return(0);
  239.         savex -= VGwin[vw].charx;
  240.         if (savex < VGwin[vw].textcol) savex = VGwin[vw].textcol;
  241.         VGwin[vw].cury=savey;
  242.         VGwin[vw].curx=savex;
  243.         return(0);
  244.     }
  245.  
  246.     hmag = VGwin[vw].charx / 10;
  247.     vmag = VGwin[vw].chary / 10;
  248.  
  249.     if (3071 - savey < VGwin[vw].chary) {
  250.         savey=y=3071-VGwin[vw].chary;
  251.     }
  252.  
  253.     if (c<32 || c>126) 
  254.         return(0);
  255.     c -= 32;
  256.     pstroke = VGfont[c];
  257.     while (*pstroke) {
  258.         strokex=x;
  259.         strokey=y;
  260.         n = (*(pstroke++) - 48);    /* run length */
  261.         c = *(pstroke++);            /* direction code */
  262.  
  263.         switch(c) { /* horizontal movement: positive = right */
  264.         case 'e': case 'd': case 'c': case 'y': case 'h': case 'n':
  265.             x += n * hmag;
  266.             break;
  267.  
  268.         case 'q': case 'a': case 'z': case 'r': case 'f': case 'v':
  269.             x -= n * hmag;
  270.         }
  271.  
  272.         switch(c) { /* vertical movement: positive = up */
  273.         case 'q': case 'w': case 'e': case 'r': case 't': case 'y':
  274.             y += n * vmag;
  275.             break;
  276.         case 'z': case 'x': case 'c': case 'v': case 'b': case 'n':
  277.             y -= n * vmag;
  278.         }
  279.  
  280.         switch(c) { /* draw or move */
  281.         case 'r': case 't': case 'y': case 'f': case 'h':
  282.         case 'v': case 'b': case 'n':
  283.             clipvec (vw,strokex,strokey,x,y);
  284.             break;
  285.         }
  286.     
  287.     } /* end while not at end of string */
  288.  
  289.     /* Update cursor location to next char position */
  290.     if (savex + 2 * VGwin[vw].chary <= 4096) savex += VGwin[vw].charx;
  291.     else {
  292.         savey -= VGwin[vw].chary;
  293.         if (savey<0) {
  294.             savey=3071 - VGwin[vw].chary;
  295.             VGwin[vw].textcol = 2048 - VGwin[vw].textcol;
  296.         }
  297.         savex = VGwin[vw].textcol;
  298.     }
  299.  
  300.     VGwin[vw].cury=savey;
  301.     VGwin[vw].curx=savex;
  302.  
  303. } /* end drawc() */
  304. #endif
  305.  
  306. static clipt(p,q,t0,t1)
  307. float p,q,*t0,*t1;
  308. /* To be called only by clipvec() */
  309. {
  310.     float r;
  311.     int accept = TRUE;
  312.  
  313.     if (p<0.0) {
  314.         r = q/p;
  315.         if (r>*t1) accept = FALSE;
  316.         else if (r>*t0) *t0 = r;
  317.     }
  318.     else if (p>0.0) {
  319.         r = q/p;
  320.         if (r<*t0) accept = FALSE;
  321.         else if (r<*t1) *t1 = r;
  322.     }
  323.     else if (q<0.0) accept = FALSE;
  324.     return(accept);
  325. }
  326.  
  327. #ifdef DEBUG
  328. clipvec(vw,xa,ya,xb,yb)
  329. int vw;
  330. int xa,ya,xb,yb;
  331. {
  332.     printf("%d,%d to %d,%d\n",xa,ya,xb,yb);
  333. }
  334. #else
  335. static clipvec(vw,xa,ya,xb,yb)
  336. int vw;
  337. int xa,ya,xb,yb;
  338.  
  339. /*
  340.     Draw a vector in vw's window from x0,y0 to x1,y1.
  341.     Zoom the vector to the current visible window,
  342.     and clip it before drawing it.
  343.     Uses Liang-Barsky algorithm from ACM Transactions on Graphics,
  344.         Vol. 3, No. 1, January 1984, p. 7.
  345. */
  346. {
  347.     int t,b,l,r;
  348.     float x0,y0,x1,y1,t0,t1,deltay,deltax;
  349.     struct VGWINTYPE *vp;
  350.     vp = &VGwin[vw];
  351.  
  352. #ifdef otherway
  353.     /* degenerate single points: do not draw */
  354.     if (xa==xb && ya==yb) return;
  355. #endif
  356.  
  357.     t=vp->wintop;
  358.     b=vp->winbot;
  359.     l=vp->winleft;
  360.     r=vp->winright;
  361.  
  362.     /* totally visible */
  363.     if (xa<=r && xb<=r && xa>=l && xb>=l
  364.     &&  ya<=t && yb<=t && ya>=b && yb>=b) {
  365.         (*RG[vp->RGdevice].drawline) (vp->RGnum,
  366.         (int) ((long)(xa - l) * RGXSIZE / vp->winwide),
  367.         (int) ((long)(ya- b) * RGYSIZE / vp->wintall),
  368.         (int) ((long)(xb - l) * RGXSIZE / vp->winwide),
  369.         (int) ((long)(yb- b) * RGYSIZE / vp->wintall));
  370.         return;
  371.     }
  372.  
  373.     /* trivially invisible */
  374.     if ((xa>r && xb>r) || (xa<l && xb<l) 
  375.     || (ya<b && yb<b) || (ya>t && yb>t)) {
  376.         return;
  377.     }
  378.     
  379.     /* the clipping algorithm */
  380.     x0=(float) xa;
  381.     y0=(float) ya;
  382.     x1=(float) xb;
  383.     y1=(float) yb;
  384.  
  385.     t0=0.0;
  386.     t1=1.0;
  387.     deltax = x1-x0;
  388.  
  389.     if(clipt(-deltax, x0 - l, &t0, &t1)) {
  390.         if (clipt(deltax, r - x0, &t0, &t1)) {
  391.             deltay = y1 - y0;
  392.             if (clipt(-deltay, y0 - b, &t0, &t1)) {
  393.                 if (clipt(deltay, t - y0, &t0, &t1)) {
  394.                     if (t1<1.0) {
  395.                         x1 = x0 + t1*deltax;
  396.                         y1 = y0 + t1*deltay;
  397.                     }
  398.                     if (t0>0.0) {
  399.                         x0 += t0*deltax;
  400.                         y0 += t0*deltay;
  401.                     }
  402. /* draw the line, it is at least partially visible */
  403.     (*RG[vp->RGdevice].drawline) (vp->RGnum,
  404.     (int) ((long)((int)x0 - l) * RGXSIZE / vp->winwide),
  405.     (int) ((long)((int)y0- b) * RGYSIZE / vp->wintall),
  406.     (int) ((long)((int)x1 - l) * RGXSIZE / vp->winwide),
  407.     (int) ((long)((int)y1- b) * RGYSIZE / vp->wintall));
  408.  
  409.                 } 
  410.             } 
  411.         } 
  412.     } /* end if */
  413.  
  414.  
  415. } /* end clipvec() */
  416. #endif
  417.  
  418. /*******************************************************
  419. ********************************************************
  420.  
  421. All routines given below may be called by the user
  422. program.  No routines given above may be called from
  423. the user program.
  424.  
  425. ********************************************************
  426. *******************************************************/
  427.  
  428.  
  429. VGinit()
  430. /*
  431.     Initialize the whole VG environment.  Should be called ONCE
  432.     at program startup before using the VG routines.
  433. */
  434. {
  435.     int i;
  436.     for (i=0; i<MAXVG; i++) {
  437.         VGwin[i].RGdevice = -1; /* no device */
  438.     }
  439. #ifndef DEBUG
  440.     for (i=0; i<MAXRG; i++) { (*RG[i].init)(); }
  441. #endif
  442. }
  443.  
  444.  
  445. VGuncover(vw)
  446. /*
  447.     Make sure window is completely visible, rather than partly or
  448.     completely invisible.
  449.     This function is to be called whenever a window is made active,
  450.     to ensure that the user can see it.
  451. */
  452. {
  453. #ifndef DEBUG
  454.     (*RG[VGwin[vw].RGdevice].uncover)(VGwin[vw].RGnum);
  455. #endif
  456. }
  457.  
  458.  
  459. VGdevice(vw,dev)
  460. int vw,dev;
  461. /*
  462.     Detach window from its current device and attach it to the
  463.     specified device.  Returns negative number if unable to do so.
  464.     Sample application:  switching an image from #9 to Hercules.
  465.     Must redraw after calling this.
  466. */
  467. {
  468.     int newwin;
  469.  
  470.     newwin = (*RG[dev].newwin)();
  471.     if (newwin<0) return(newwin); /* unable to open new window */
  472.  
  473.     (*RG[VGwin[vw].RGdevice].close)(VGwin[vw].RGnum);
  474.     VGwin[vw].RGdevice = dev;
  475.     VGwin[vw].RGnum = newwin;
  476.     VGwin[vw].pencolor = 1;
  477.     fontnum(vw,1);
  478.     return(0);
  479. }
  480.  
  481.  
  482. VGnewwin(device)
  483. int device; /* number of RG device to use */
  484. /*
  485.     Create a new VG window and return its number.
  486.     New window will be attached to specified real device.
  487.     Returns -1 if unable to create a new VG window.
  488. */
  489. {
  490.     int vw=0;
  491.     while (vw<MAXVG && VGwin[vw].RGdevice != -1) vw++;
  492.     if (vw == MAXVG) {
  493.         return(-1);
  494.     }
  495.     VGstore[vw] = newstore();
  496.     if (VGstore[vw] == NULL) {
  497.         return(-1); /* no memory */
  498.     }
  499.     VGwin[vw].RGdevice=device;
  500.  
  501.     VGwin[vw].RGnum = (*RG[device].newwin)();
  502.     if (VGwin[vw].RGnum< 0) {
  503.         /* no windows available on device */
  504.         freestore(VGstore[vw]);
  505.         return(-1);
  506.     }
  507.             
  508.     VGwin[vw].mode=ALPHA;
  509.     state[vw]=DONE;
  510.     storing[vw]=TRUE;
  511.     VGwin[vw].textcol=0;
  512.     drawing[vw]=1;
  513.     fontnum(vw,0);
  514.     (*RG[device].pencolor)(VGwin[vw].RGnum,1);
  515.  
  516.     storexy(vw,0,3119);
  517.     VGzoom(vw,0,0,4095,3119);
  518.     return(vw);
  519. }
  520.  
  521.  
  522. VGclrstor(vw)
  523. int vw;
  524. /* 
  525.     Clear the store associated with window vw.  
  526.     All contents are lost.
  527.     User program can call this whenever desired.
  528.     Automatically called after receipt of Tek page command.
  529. */
  530. {
  531.     freestore(VGstore[vw]);
  532.     VGstore[vw] = newstore();
  533.         /* Don't have to check for errors; there was definitely
  534.         enough memory. */
  535. }
  536.  
  537.  
  538. VGdumpstore(vw,func)
  539. int vw;
  540. int (*func)();
  541. /*
  542.     Successively call the function pointed to by 'func' for each
  543.     character stored from window vw.  Each character will
  544.     be passed in integer form as the only parameter.  A value of -1
  545.     will be passed on the last call to indicate the end of the data.
  546. */
  547. {
  548.     int data;
  549.     STOREP st=VGstore[vw];
  550.  
  551.     topstore(st);
  552.     while ((data=nextitem(st)) != -1) (*func)(data);
  553.     (*func)(-1);
  554. }
  555.  
  556.  
  557. VGdraw(vw,c)
  558. int vw;
  559. char c; /* the latest input char */
  560. /*
  561.     This is the main Tek emulator process.  Pass it the window and
  562.     the latest input character, and it will take care of the rest.
  563.     Calls RG functions as well as local zoom and character drawing
  564.     functions.
  565. */
  566. {
  567.     char cmd;
  568.     char value;
  569.     char goagain; /* true means go thru the function a second time */
  570.     struct VGWINTYPE *vp;
  571.     vp = &VGwin[vw];
  572.  
  573.  
  574.     /*** MAIN LOOP ***/
  575.      do {
  576.  
  577.         cmd=(c >> 5) & 0x03;
  578.         value=c & 0x1f;
  579.         goagain=FALSE;
  580.  
  581.         switch(state[vw]) {
  582.  
  583.         case HIY: /* beginning of a vector */
  584.             vp->nhiy = vp->hiy;
  585.             vp->nhix = vp->hix;
  586.             vp->nloy = vp->loy;
  587.             vp->nlox = vp->lox;
  588.             vp->ney  = vp->ey;
  589.             vp->nex  = vp->ex;
  590.     
  591.             switch(cmd) {
  592.             case 0:
  593.                 if (value == 27) {        /* escape sequence */
  594.                     state[vw] = ESCOUT;
  595.                     savstate[vw] = HIY;
  596.                 }
  597.                 else if (value < 27) {    /* ignore */
  598.                     break;
  599.                 }
  600.                 else {
  601.                     state[vw]=CANCEL;
  602.                     goagain=TRUE;
  603.                 }
  604.                 break;
  605.             case 1: /* hiy */
  606.                 vp->nhiy=value;
  607.                 state[vw]=EXTRA;
  608.                 break;
  609.             case 2: /* lox */
  610.                 vp->nlox=value;
  611.                 state[vw]=DONE;
  612.                 break;
  613.             case 3: /* extra or loy */
  614.                 vp->nloy=value;
  615.                 state[vw]=LOY;
  616.                 break;
  617.             }
  618.             break;        
  619.     
  620.         case ESCOUT:
  621.             if (value != 13 && value != 10
  622.                 && value != 27 && value != '~') {/* skip all EOL-type characters */
  623.                 state[vw] = savstate[vw];
  624.                 goagain = TRUE;
  625.             }
  626.             break;
  627.  
  628.         case EXTRA:    /* got hiy; expecting extra or loy */
  629.             switch(cmd) {
  630.             case 0:
  631.                 if (value == 27) {        /* escape sequence */
  632.                     state[vw] = ESCOUT;
  633.                     savstate[vw] = EXTRA;
  634.                 }
  635.                 else if (value < 27) {    /* ignore */
  636.                     break;
  637.                 }
  638.                 else {
  639.                     state[vw]=DONE;
  640.                     goagain=TRUE;
  641.                 }
  642.                 break;
  643.             case 1: /* hix */
  644.                 vp->nhix=value;
  645.                 state[vw]=LOX;
  646.                 break;
  647.             case 2: /* lox */
  648.                 vp->nlox=value;
  649.                 state[vw]=DONE;
  650.                 break;
  651.             case 3: /* extra or loy */
  652.                 vp->nloy=value;
  653.                 state[vw]=LOY;
  654.                 break;
  655.             }
  656.             break;
  657.     
  658.         case LOY: /* got extra or loy; next may be loy or something else */
  659.             switch(cmd) {
  660.             case 0:
  661.                 if (value == 27) {        /* escape sequence */
  662.                     state[vw] = ESCOUT;
  663.                     savstate[vw] = LOY;
  664.                 }
  665.                 else if (value < 27) {    /* ignore */
  666.                     break;
  667.                 }
  668.                 else {
  669.                     state[vw]=DONE;
  670.                     goagain=TRUE;
  671.                 }
  672.                 break;
  673.             case 1: /* hix */
  674.                 vp->nhix=value;
  675.                 state[vw]=LOX;
  676.                 break;
  677.             case 2: /* lox */
  678.                 vp->nlox=value;
  679.                 state[vw]=DONE;
  680.                 break;
  681.             case 3: /* this is loy; previous loy was really extra */
  682.                 vp->ney = (vp->nloy >> 2) & 3;
  683.                 vp->nex = (vp->nlox) & 3;
  684.                 vp->nloy=value;
  685.                 state[vw]=HIX;
  686.                 break;
  687.             }
  688.             break;
  689.     
  690.         case HIX: /* hix or lox */
  691.             switch(cmd) {
  692.             case 0:
  693.                 if (value == 27) {        /* escape sequence */
  694.                     state[vw] = ESCOUT;
  695.                     savstate[vw] = HIX;
  696.                 }
  697.                 else if (value < 27) {    /* ignore */
  698.                     break;
  699.                 }
  700.                 else {
  701.                     state[vw]=DONE;
  702.                     goagain=TRUE;
  703.                 }
  704.                 break;
  705.             case 1: /* hix */
  706.                 vp->nhix=value;
  707.                 state[vw]=LOX;
  708.                 break;
  709.             case 2: /* lox */
  710.                 vp->nlox=value;
  711.                 state[vw]=DONE;
  712.                 break;
  713.             }
  714.              break;
  715.     
  716.         case LOX: /* must be lox */
  717.             switch(cmd) {
  718.             case 0:
  719.                 if (value == 27) {        /* escape sequence */
  720.                     state[vw] = ESCOUT;
  721.                     savstate[vw] = LOX;
  722.                 }
  723.                 else if (value < 27) {    /* ignore */
  724.                     break;
  725.                 }
  726.                 else {
  727.                     state[vw]=DONE;
  728.                     goagain=TRUE;
  729.                 }
  730.                 break;
  731.             case 2:
  732.                 vp->nlox=value;
  733.                 state[vw]=DONE;
  734.                 break;
  735.             }
  736.             break;
  737.     
  738.         case ENTERVEC:
  739.             if (c==7) vp->mode = DRAW;
  740.             if (c < 27)
  741.                 break;
  742.             state[vw] = HIY;
  743.             vp->mode = TEMPMOVE;
  744.             vp->modesave = DRAW;
  745.             goagain = TRUE;
  746.             break;
  747.  
  748.         case RS:
  749.             switch (c) {
  750.             case ' ':                /* pen up */
  751.                 vp->modesave = vp->mode;
  752.                 vp->mode = TEMPMOVE;
  753.                 break;
  754.             case 'P':                /* pen down */
  755.                 vp->mode = DRAW;
  756.                 break;
  757.             case 'D':                /* move up */
  758.                 vp->cury++;
  759.                 break;
  760.             case 'E':
  761.                 vp->cury++;
  762.                 vp->curx++;
  763.                 break;
  764.             case 'A':
  765.                 vp->curx++;
  766.                 break;
  767.             case 'I':
  768.                 vp->curx++;
  769.                 vp->cury--;
  770.                 break;
  771.             case 'H':
  772.                 vp->cury--;
  773.                 break;
  774.             case 'J':
  775.                 vp->curx--;
  776.                 vp->cury--;
  777.                 break;
  778.             case 'B':
  779.                 vp->curx--;
  780.                 break;
  781.             case 'F':
  782.                 vp->cury++;
  783.                 vp->curx--;
  784.                 break;
  785.             case 27:
  786.                 savstate[vw] = RS;
  787.                 state[vw] = ESCOUT;
  788.                 break;
  789.  
  790.             default:
  791. /*                storexy(vw,vp->curx,vp->cury);*/
  792.                 state[vw] = CANCEL;
  793.                 goagain = TRUE;
  794.                 break;
  795.             }
  796.             if (vp->mode == DRAW)
  797.                 clipvec(vw,vp->curx,vp->cury,vp->curx,vp->cury);
  798. #ifdef DEBUG
  799.             printf("RS: %d,%d\n",vp->curx,vp->cury);
  800. #endif
  801.             break;
  802.  
  803.         case CMD0: /* get 1st letter of cmd */
  804.             switch(c) {
  805.             case 29:                    /* GS, start draw */
  806.                 state[vw] = DONE;
  807.                 goagain = TRUE;
  808.                 break;
  809.             case '8':
  810.                 fontnum(vw,0);
  811.                 state[vw]=DONE;
  812.                 break;
  813.             case '9':
  814.                 fontnum(vw,1);
  815.                 state[vw]=DONE;
  816.                 break;
  817.             case ':':
  818.                 fontnum(vw,2);
  819.                 state[vw]=DONE;
  820.                 break;
  821.             case ';':
  822.                 fontnum(vw,3);
  823.                 state[vw]=DONE;
  824.                 break;
  825.             case 12: /* form feed = clrscr */
  826.                 VGpage(vw);
  827.                 VGclrstor(vw);                
  828.                 break;
  829.             case 'L':
  830.                 state[vw] = SOMEL;
  831.                 break;
  832.             case 'K':
  833.                 state[vw] = IGNORE;
  834.                 break;
  835.             case 'M':
  836.                 state[vw] = SOMEM;
  837.                 break;
  838.             case 'T':
  839.                 state[vw] = SOMET;
  840.                 break;
  841.             case 26:
  842.                 (*RG[vp->RGdevice].gin)(vp->RGnum);
  843.                 unstore(VGstore[vw]);
  844.                 unstore(VGstore[vw]);
  845.                 break;
  846.             case 10:
  847.             case 13:
  848.             case 27:
  849.             case '~':
  850.                 savstate[vw] = DONE;
  851.                 state[vw] = ESCOUT;
  852.                 break;            /* completely ignore these after ESC */
  853.             default:
  854.                 state[vw] = DONE;
  855.             } /* end switch */
  856.             break;
  857.     
  858.         case SOMET:
  859.             /* Got ESC T; now handle 3rd char. */
  860.             switch(c) {
  861.             case 'G': /* set surface color map */
  862.                 state[vw]=INTEGER;
  863.                 savstate[vw]=JUNKARRAY;
  864.                 break;
  865.             case 'F': /* set dialog area color map */
  866.                 state[vw]=JUNKARRAY;
  867.                 break;
  868.             default:
  869.                 state[vw]=DONE;
  870.             }            
  871.             break;
  872.  
  873.         case JUNKARRAY:
  874.             /* This character is the beginning of an integer array
  875.             to be discarded.  Get array size. */
  876.             savstate[vw]=STARTDISC;
  877.             state[vw]=INTEGER;
  878.             break;                    
  879.  
  880.         case STARTDISC:
  881.             /* Begin discarding integers. */
  882.             vp->count = vp->intin + 1;
  883.             goagain=TRUE;
  884.             state[vw]=DISCARDING;
  885.             break;
  886.  
  887.         case DISCARDING:
  888.             /* We are in the process of discarding an integer array. */
  889.             goagain=TRUE;
  890.             if (!(--(vp->count))) state[vw]=DONE;
  891.             else if (vp->count==1) {
  892.                 state[vw]=INTEGER;
  893.                 savstate[vw]=DONE;
  894.             } else {
  895.                 state[vw]=INTEGER;
  896.                 savstate[vw]=DISCARDING;
  897.             }
  898.             break;
  899.  
  900.         case INTEGER:
  901.             if (c & 0x40) {
  902.                 vp->intin = c & 0x3f;
  903.                 state[vw] = INTEGER1;
  904.             } else {
  905.                 vp->intin = c & 0x0f;
  906.                 if (!(c & 0x10)) vp->intin *= -1;
  907.                 state[vw] = savstate[vw];
  908.             }
  909.             break;
  910.  
  911.         case INTEGER1:
  912.             if (c & 0x40) {
  913.                 vp->intin = (vp->intin << 6) | (c & 0x3f);
  914.                 state[vw] = INTEGER2;
  915.             } else {
  916.                 vp->intin = (vp->intin << 4) | (c & 0x0f);
  917.                 if (!(c & 0x10)) vp->intin *= -1;
  918.                 state[vw] = savstate[vw];
  919.             }
  920.             break;
  921.  
  922.         case INTEGER2:
  923.             vp->intin = (vp->intin << 4) | (c & 0x0f);
  924.             if (!(c & 0x10)) vp->intin *= -1;
  925.             state[vw] = savstate[vw];
  926.             break;
  927.  
  928.         case IGNORE: /* ignore next char; it's not supported */
  929.             state[vw]=DONE;
  930.             break;
  931.     
  932.         case IGNORE2: /* ignore next 2 chars */
  933.             state[vw]=IGNORE;
  934.             break;
  935.  
  936.         case SOMEL: /* now process 2nd letter */
  937.             switch(c) {
  938.             case 'F': /* move */
  939.                 vp->modesave = vp->mode;
  940.                 vp->mode = TEMPMOVE;
  941.                 state[vw] = HIY;
  942.                 break;
  943.             case 'G': /* draw */
  944.                 vp->modesave = vp->mode;
  945.                 vp->mode = TEMPDRAW;
  946.                 state[vw] = HIY;
  947.                 break;
  948.             case 'H': /* marker */
  949.                 vp->modesave = vp->mode;
  950.                 vp->mode = TEMPMARK;
  951.                 state[vw] = HIY;
  952.                 break;    
  953.             default:
  954.                 state[vw]=DONE;
  955.             } /* end switch */
  956.             break;
  957.     
  958.         case SOMEM:
  959.             switch(c) {
  960.             case 'C': /* set graphtext size */
  961.                 savstate[vw]=GTSIZE0;
  962.                 state[vw]=INTEGER;
  963.                 break;
  964.             case 'L': /* set line index */
  965.                 savstate[vw]=COLORINT;
  966.                 state[vw]=INTEGER;
  967.                 break;
  968.             default:
  969.                 state[vw]=DONE;
  970.             } /* end switch */
  971.             break;
  972.     
  973.         case COLORINT: /* set line index; have integer */
  974.             vp->pencolor=vp->intin;
  975.             (*RG[vp->RGdevice].pencolor)
  976.                 (vp->RGnum,vp->intin);
  977.             state[vw]=DONE;
  978.             goagain=TRUE; /* we ignored current char; now process it */
  979.             break;
  980.  
  981.         case GTSIZE0:
  982.             /* discard the first integer; get the 2nd */
  983.             state[vw]=INTEGER; /* get the important middle integer */
  984.             savstate[vw]=GTSIZE1;
  985.             goagain=TRUE;
  986.             break;
  987.  
  988.         case GTSIZE1:
  989.             /* integer is the height */
  990.             if (vp->intin < 88) fontnum(vw,0);
  991.             else if (vp->intin < 149) fontnum(vw,4);
  992.             else fontnum(vw,5);
  993.             state[vw]=INTEGER; /* discard last integer */
  994.             savstate[vw]=DONE;
  995.             goagain=TRUE;
  996.             break;
  997.  
  998.         case DONE: /* ready for anything */
  999.             switch(c) {
  1000.             case 31:
  1001.                 vp->mode=ALPHA; 
  1002.                 state[vw]=CANCEL;
  1003.                 break;
  1004.             case 30:
  1005.                 state[vw]=RS;
  1006.                 break;
  1007.             case 28:
  1008.                 if (cmd) {
  1009.                     vp->mode=MARK;
  1010.                     state[vw]=HIY;
  1011.                     }
  1012.                 break;
  1013.             case 29:
  1014.                 state[vw]=ENTERVEC;
  1015.                 break;
  1016.             case 27:
  1017.                 state[vw]=CMD0;
  1018.                 break;
  1019.             default:
  1020.                 if (vp->mode==ALPHA) { 
  1021.                     drawc(vw,c);
  1022.                     state[vw]=CANCEL;
  1023.                 }
  1024.                 else if (vp->mode==DRAW && cmd) {
  1025.                     state[vw]=HIY;
  1026.                     goagain=TRUE;
  1027.                 }
  1028.                 else if (vp->mode==MARK && cmd) {
  1029.                     state[vw]=HIY;
  1030.                     goagain=TRUE;
  1031.                 }
  1032.                 else
  1033.                     state[vw] = CANCEL;    /* do nothing */                
  1034.             } /* end switch(c) */
  1035.         } /* end switch(state) */
  1036.     
  1037.         if (state[vw]==DONE) {
  1038.             if (vp->mode==TEMPMOVE) {
  1039.                 vp->mode=vp->modesave;
  1040.                 newcoord(vw);
  1041.                 }
  1042.             else if (vp->mode==DRAW || vp->mode==TEMPDRAW) {
  1043. #ifdef oldm
  1044.                 clipvec(vw,
  1045.                     joinup(vp->hix,vp->lox,vp->ex),
  1046.                     joinup(vp->hiy,vp->loy,vp->ey),
  1047.                     joinup(vp->nhix,vp->nlox,vp->nex),
  1048.                     joinup(vp->nhiy,vp->nloy,vp->ney));
  1049. #endif
  1050.                 clipvec(vw,vp->curx,vp->cury,
  1051.                     joinup(vp->nhix,vp->nlox,vp->nex),
  1052.                     joinup(vp->nhiy,vp->nloy,vp->ney));
  1053.  
  1054.                 if (vp->mode==TEMPDRAW) vp->mode=vp->modesave;
  1055.                 newcoord(vw);
  1056.                 }
  1057.             else if (vp->mode==MARK || vp->mode==TEMPMARK) {
  1058.                 /* draw marker */
  1059.                 newcoord(vw);
  1060.                 }
  1061.             } /* end if done */
  1062.  
  1063.         if (state[vw]==CANCEL) state[vw]=DONE;
  1064.  
  1065.     } while (goagain);
  1066.     /*** END OF MAIN LOOP ***/
  1067.  
  1068. } /* end VGdraw() */
  1069.  
  1070.  
  1071. VGpage(vw)
  1072. int vw;
  1073. /*  Clear screen and have a few other effects:
  1074.     - Return graphics to home position (0,3071)
  1075.     - Switch to alpha mode
  1076.     This is a standard Tek command; don't look at me.
  1077. */
  1078. {
  1079. #ifndef DEBUG
  1080.     (*RG[VGwin[vw].RGdevice].clrscr)(VGwin[vw].RGnum);
  1081.     (*RG[VGwin[vw].RGdevice].pencolor)(VGwin[vw].RGnum,1);
  1082. #endif
  1083.     VGwin[vw].mode=ALPHA;
  1084.     state[vw] = DONE;
  1085.     VGwin[vw].textcol=0;
  1086.     fontnum(vw,0);
  1087.     storexy(vw,0,3071);
  1088. } /* end page */
  1089.  
  1090.  
  1091. VGpred(vw,dest)
  1092. int vw,dest;
  1093. /*
  1094.     Redraw window 'vw' in pieces to window 'dest'.
  1095.     Must call this function repeatedly to draw whole image.
  1096.     Only draws part of the image at a time, to yield CPU power.
  1097.     Returns 0 if needs to be called more, or 1 if the image
  1098.     is complete.  Another call would result in the redraw beginning again.
  1099.     User should clear screen before beginning redraw.
  1100. */
  1101. {
  1102.     int data;
  1103.     STOREP st=VGstore[vw];
  1104.     int count=0;
  1105.  
  1106.     if (drawing[vw]) {        /* wasn't redrawing */
  1107.         topstore(st);
  1108.         drawing[vw] = 0;    /* redraw incomplete */
  1109.     }
  1110.  
  1111.     while ( ++count < PREDCOUNT && ((data=nextitem(st)) != -1) ) {
  1112.         VGdraw(dest,data);
  1113.     }
  1114.  
  1115.     if (data == -1) drawing[vw] = 1; /* redraw complete */
  1116.     return(drawing[vw]);
  1117. }
  1118.  
  1119.  
  1120. VGstopred(vw,dest)
  1121. /*
  1122.     Abort VGpred redrawing of specified window.
  1123.     Must call this routine if you decide not to complete the redraw.
  1124. */
  1125. {
  1126.     drawing[vw]=1;
  1127. }
  1128.  
  1129.  
  1130. VGredraw(vw,dest)
  1131. int vw,dest;
  1132. /*
  1133.     Redraw the contents of window 'vw' to window 'dest'.
  1134.     Does not yield CPU until done.
  1135.     User should clear the screen before calling this, to avoid 
  1136.     a messy display.
  1137. */
  1138. {
  1139.     int data;
  1140.     STOREP st=VGstore[vw];
  1141.  
  1142.     topstore(st);
  1143.     while ((data=nextitem(st)) != -1) {
  1144.         VGdraw(dest,data);
  1145.     }
  1146. }
  1147.  
  1148.  
  1149. VGzoom(vw,x0,y0,x1,y1)
  1150. /*
  1151.     Set new borders for zoom/pan region.
  1152.     x0,y0 is lower left; x1,y1 is upper right.
  1153.     User should redraw after calling this.
  1154. */
  1155. {
  1156.     VGwin[vw].winbot=y0;
  1157.     VGwin[vw].winleft=x0;
  1158.     VGwin[vw].wintop=y1;
  1159.     VGwin[vw].winright=x1;
  1160.     VGwin[vw].wintall = y1-y0+1;
  1161.     VGwin[vw].winwide = x1-x0+1;
  1162.     VGgiveinfo(vw);
  1163. }
  1164.  
  1165.  
  1166. VGzcpy(src,dest)
  1167. /*
  1168.     Set zoom/pan borders for window 'dest' equal to those for window 'src'.
  1169.     User should redraw window 'dest' after calling this.
  1170. */
  1171. {
  1172.     VGzoom(dest,VGwin[src].winleft, VGwin[src].winbot,
  1173.     VGwin[src].winright, VGwin[src].wintop);
  1174. }
  1175.  
  1176.  
  1177. VGclose(vw)
  1178. /*
  1179.     Close virtual window.
  1180.     Release its real graphics device and its store.
  1181. */
  1182. {
  1183.     (*RG[VGwin[vw].RGdevice].close)(VGwin[vw].RGnum);
  1184.     freestore(VGstore[vw]);
  1185.     VGwin[vw].RGdevice = -1;
  1186. }
  1187.  
  1188.  
  1189. VGwrite(vw,data,count)
  1190. int vw, count;
  1191. char *data;
  1192. /*
  1193.     Draw the data pointed to by 'data' of length 'count'
  1194.     on window vw, and add it to the store for that window.
  1195.     This is THE way for user program to pass Tektronix data.
  1196. */
  1197. {
  1198.     char *c = data;
  1199.     char *end = &(data[count]);
  1200.  
  1201.     if (VGwin[vw].RGdevice == -1 || vw >= MAXVG || vw < 0) return(-1);
  1202.         /* window not open */
  1203.  
  1204.     if (storing[vw]) {
  1205.         while (c != end) {
  1206.             addstore(VGstore[vw], *c);
  1207.             VGdraw(vw,*c++);
  1208.         }
  1209.     } else {
  1210.         while (c != end) VGdraw(vw,*c++);
  1211.     }
  1212.     return(0);
  1213. }
  1214.  
  1215.  
  1216. VGgiveinfo(vw)
  1217. int vw;
  1218. /*
  1219.     Send interesting information about the virtual window down to
  1220.     its RG, so that the RG can make VG calls and display zoom values
  1221. */
  1222. {
  1223.     (*RG[VGwin[vw].RGdevice].info)(VGwin[vw].RGnum,
  1224.     vw,
  1225.     VGwin[vw].winbot,
  1226.     VGwin[vw].winleft,
  1227.     VGwin[vw].wintop,
  1228.     VGwin[vw].winright);
  1229. }
  1230.  
  1231.  
  1232. char *
  1233. VGrgname(rgdev)
  1234. int rgdev;
  1235. /*
  1236.     Return a pointer to a human-readable string
  1237.     which describes the specified real device
  1238. */
  1239. {
  1240.     return(*RG[rgdev].devname)();
  1241. }
  1242.  
  1243.  
  1244. VGgmode(rgdev)
  1245. int rgdev;
  1246. /* Put the specified real device into graphics mode */
  1247. {
  1248. #ifndef DEBUG
  1249.     (*RG[rgdev].gmode)();
  1250. #endif
  1251. }
  1252.  
  1253.  
  1254. VGtmode(rgdev)
  1255. int rgdev;
  1256. /* Put the specified real device into text mode */
  1257. {
  1258.     (*RG[rgdev].tmode)();
  1259. }
  1260.  
  1261.  
  1262. VGgindata(vw,x,y,c,a)
  1263. int vw,x,y;
  1264. char c;
  1265. char *a;
  1266. /*
  1267.     Translate data for output as GIN report.
  1268.  
  1269.     User indicates VW number and x,y coordinates of the GIN cursor.
  1270.     Coordinate space is 0-4095, 0-4095 with 0,0 at the bottom left of
  1271.     the real window and 4095,4095 at the upper right of the real window.
  1272.     'c' is the character to be returned as the keypress.
  1273.     'a' is a pointer to an array of 5 characters.  The 5 chars must
  1274.     be transmitted by the user to the remote host as the GIN report.
  1275. */
  1276. {
  1277.     long x2,y2;
  1278.  
  1279.     x2 = ((x * VGwin[vw].winwide) / RGXSIZE + VGwin[vw].winleft) >> 2;
  1280.     y2 = ((y * VGwin[vw].wintall) / RGYSIZE + VGwin[vw].winbot) >> 2;
  1281.  
  1282.     a[0] = c;
  1283.     a[1] = 0x20 | ((x2 & 0x03E0) >> 5);
  1284.     a[2] = 0x20 | (x2 & 0x001F);
  1285.     a[3] = 0x20 | ((y2 & 0x03E0) >> 5);
  1286.     a[4] = 0x20 | (y2 & 0x001F);
  1287. }
  1288.